In performing a business task or requesting an action on a network, it may be necessary to obtain data or services from multiple separate or independent systems. Connecting to the first system is traditionally handled with a stateful transaction. There are generally two traditional approaches to connecting to the second system, both of which have disadvantages.
Under a first traditional approach, a user device initiates a stateful transaction in the first system to enable the user device to obtain data from the system. With synchronous remote function calls (RFCs), the first system could establish a connection with the second system, and initiate a stateful transaction in the second system to perform an operation in the second system. The transactions in the first and second systems have the same duration as a controlling business transaction associated with the business task or business process. Such an approach is generally performed where a dedicated software application handles synchronization of the front end with the stateful transactions of both the first and second systems. To trigger an additional action in the second system, the first system could call the second system again by synchronous RFC, reentering the context of the first call. When all processing was performed, everything could be either committed or rolled back in the two systems. The fact that two systems were performing operations to complete the process was transparent to a user in such a system. Due to its stateful nature, the second system can have interactions with the user that are routed through the first system, and user input can be directly routed to the second system and reach the original context. Such directly routed user interaction is completely transparent to the first (calling) system.
However, many systems now perform processes with the use of service requests. The services are generally accessed from a web browser and the results of the operations are presented in the browser. With the access of systems via services and the presentation of results in a web browser, the possibility of synchronous RFC for user interaction no longer exists. Thus, a second approach is becoming more common as more systems offer processing via services. The transactions in the second system are stateless, and end after the completion of the call. As used herein, a stateless transaction or service request refers to a transaction that ends after exactly one round of communication, in contrast to a stateful transaction. The stateless transaction may or may not result in a change to data or system state of the system processing the stateless transaction, and may or may not generate a reply to the caller. Thus, state is not persisted, and there is traditionally no mechanism for reentering the same context again for a second call. To commit a transaction, the first system must initiate another stateless transaction including all information necessary to commit the entire transaction. Due to its stateless nature, the second system can have no direct interaction with the user. At best, the second system provides information to the first system, which executes the user interaction and then calls the second system in a new stateless service call. Thus, current systems either require specialized software applications, or they cannot provide the ability to have a transaction with user interaction that spans multiple systems.